home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / fish / 001-100 / 001-025 / 022 / lemacs / region.c < prev    next >
C/C++ Source or Header  |  1995-03-17  |  7KB  |  207 lines
  1. /*
  2.  * The routines in this file
  3.  * deal with the region, that magic space
  4.  * between "." and mark. Some functions are
  5.  * commands. Some functions are just for
  6.  * internal use.
  7.  */
  8. #include        <stdio.h>
  9. #include    "estruct.h"
  10. #include        "edef.h"
  11.  
  12. /*
  13.  * Kill the region. Ask "getregion"
  14.  * to figure out the bounds of the region.
  15.  * Move "." to the start, and kill the characters.
  16.  * Bound to "C-W".
  17.  */
  18. killregion(f, n)
  19. {
  20.         register int    s;
  21.         REGION          region;
  22.  
  23.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if    */
  24.         return(rdonly());    /* we are in read only mode    */
  25.         if ((s=getregion(®ion)) != TRUE)
  26.                 return (s);
  27.         if ((lastflag&CFKILL) == 0)             /* This is a kill type  */
  28.                 kdelete();                      /* command, so do magic */
  29.         thisflag |= CFKILL;                     /* kill buffer stuff.   */
  30.         curwp->w_dotp = region.r_linep;
  31.         curwp->w_doto = region.r_offset;
  32.         return (ldelete(region.r_size, TRUE));
  33. }
  34.  
  35. /*
  36.  * Copy all of the characters in the
  37.  * region to the kill buffer. Don't move dot
  38.  * at all. This is a bit like a kill region followed
  39.  * by a yank. Bound to "M-W".
  40.  */
  41. copyregion(f, n)
  42. {
  43.         register LINE   *linep;
  44.         register int    loffs;
  45.         register int    s;
  46.         REGION          region;
  47.  
  48.         if ((s=getregion(®ion)) != TRUE)
  49.                 return (s);
  50.         if ((lastflag&CFKILL) == 0)             /* Kill type command.   */
  51.                 kdelete();
  52.         thisflag |= CFKILL;
  53.         linep = region.r_linep;                 /* Current line.        */
  54.         loffs = region.r_offset;                /* Current offset.      */
  55.         while (region.r_size--) {
  56.                 if (loffs == llength(linep)) {  /* End of line.         */
  57.                         if ((s=kinsert('\n')) != TRUE)
  58.                                 return (s);
  59.                         linep = lforw(linep);
  60.                         loffs = 0;
  61.                 } else {                        /* Middle of line.      */
  62.                         if ((s=kinsert(lgetc(linep, loffs))) != TRUE)
  63.                                 return (s);
  64.                         ++loffs;
  65.                 }
  66.         }
  67.         return (TRUE);
  68. }
  69.  
  70. /*
  71.  * Lower case region. Zap all of the upper
  72.  * case characters in the region to lower case. Use
  73.  * the region code to set the limits. Scan the buffer,
  74.  * doing the changes. Call "lchange" to ensure that
  75.  * redisplay is done in all buffers. Bound to
  76.  * "C-X C-L".
  77.  */
  78. lowerregion(f, n)
  79. {
  80.         register LINE   *linep;
  81.         register int    loffs;
  82.         register int    c;
  83.         register int    s;
  84.         REGION          region;
  85.  
  86.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if    */
  87.         return(rdonly());    /* we are in read only mode    */
  88.         if ((s=getregion(®ion)) != TRUE)
  89.                 return (s);
  90.         lchange(WFHARD);
  91.         linep = region.r_linep;
  92.         loffs = region.r_offset;
  93.         while (region.r_size--) {
  94.                 if (loffs == llength(linep)) {
  95.                         linep = lforw(linep);
  96.                         loffs = 0;
  97.                 } else {
  98.                         c = lgetc(linep, loffs);
  99.                         if (c>='A' && c<='Z')
  100.                                 lputc(linep, loffs, c+'a'-'A');
  101.                         ++loffs;
  102.                 }
  103.         }
  104.         return (TRUE);
  105. }
  106.  
  107. /*
  108.  * Upper case region. Zap all of the lower
  109.  * case characters in the region to upper case. Use
  110.  * the region code to set the limits. Scan the buffer,
  111.  * doing the changes. Call "lchange" to ensure that
  112.  * redisplay is done in all buffers. Bound to
  113.  * "C-X C-L".
  114.  */
  115. upperregion(f, n)
  116. {
  117.         register LINE   *linep;
  118.         register int    loffs;
  119.         register int    c;
  120.         register int    s;
  121.         REGION          region;
  122.  
  123.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if    */
  124.         return(rdonly());    /* we are in read only mode    */
  125.         if ((s=getregion(®ion)) != TRUE)
  126.                 return (s);
  127.         lchange(WFHARD);
  128.         linep = region.r_linep;
  129.         loffs = region.r_offset;
  130.         while (region.r_size--) {
  131.                 if (loffs == llength(linep)) {
  132.                         linep = lforw(linep);
  133.                         loffs = 0;
  134.                 } else {
  135.                         c = lgetc(linep, loffs);
  136.                         if (c>='a' && c<='z')
  137.                                 lputc(linep, loffs, c-'a'+'A');
  138.                         ++loffs;
  139.                 }
  140.         }
  141.         return (TRUE);
  142. }
  143.  
  144. /*
  145.  * This routine figures out the
  146.  * bounds of the region in the current window, and
  147.  * fills in the fields of the "REGION" structure pointed
  148.  * to by "rp". Because the dot and mark are usually very
  149.  * close together, we scan outward from dot looking for
  150.  * mark. This should save time. Return a standard code.
  151.  * Callers of this routine should be prepared to get
  152.  * an "ABORT" status; we might make this have the
  153.  * conform thing later.
  154.  */
  155. getregion(rp)
  156. register REGION *rp;
  157. {
  158.         register LINE   *flp;
  159.         register LINE   *blp;
  160.         int    fsize;
  161.         register int    bsize;
  162.  
  163.         if (curwp->w_markp == NULL) {
  164.                 mlwrite("No mark set in this window");
  165.                 return (FALSE);
  166.         }
  167.         if (curwp->w_dotp == curwp->w_markp) {
  168.                 rp->r_linep = curwp->w_dotp;
  169.                 if (curwp->w_doto < curwp->w_marko) {
  170.                         rp->r_offset = curwp->w_doto;
  171.                         rp->r_size = curwp->w_marko-curwp->w_doto;
  172.                 } else {
  173.                         rp->r_offset = curwp->w_marko;
  174.                         rp->r_size = curwp->w_doto-curwp->w_marko;
  175.                 }
  176.                 return (TRUE);
  177.         }
  178.         blp = curwp->w_dotp;
  179.         bsize = curwp->w_doto;
  180.         flp = curwp->w_dotp;
  181.         fsize = llength(flp)-curwp->w_doto+1;
  182.         while (flp!=curbp->b_linep || lback(blp)!=curbp->b_linep) {
  183.                 if (flp != curbp->b_linep) {
  184.                         flp = lforw(flp);
  185.                         if (flp == curwp->w_markp) {
  186.                                 rp->r_linep = curwp->w_dotp;
  187.                                 rp->r_offset = curwp->w_doto;
  188.                                 rp->r_size = fsize+curwp->w_marko;
  189.                                 return (TRUE);
  190.                         }
  191.                         fsize += llength(flp)+1;
  192.                 }
  193.                 if (lback(blp) != curbp->b_linep) {
  194.                         blp = lback(blp);
  195.                         bsize += llength(blp)+1;
  196.                         if (blp == curwp->w_markp) {
  197.                                 rp->r_linep = blp;
  198.                                 rp->r_offset = curwp->w_marko;
  199.                                 rp->r_size = bsize - curwp->w_marko;
  200.                                 return (TRUE);
  201.                         }
  202.                 }
  203.         }
  204.         mlwrite("Bug: lost mark");
  205.         return (FALSE);
  206. }
  207.